﻿/*!
 * $ProjectName: $
 * $ProjectRevision: Last Checkpoint: $
 * $Last Checkpoint: $
 * $Source: $
 * $Revision:  $
 * $Author: $
 * $Date:  $
 *
 * Copyright © 2011
 * BEB Industrie-Elektronik AG
 * All rights reserved
 * The code is provided "as is" with no expressed or implied warranty.
 */

namespace LoadSpiellisten
{
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Windows;
    using System.Windows.Controls;
    using System.Windows.Data;
    using System.Windows.Documents;
    using System.Windows.Input;
    using System.Windows.Media;
    using System.Windows.Media.Imaging;
    using System.Windows.Navigation;
    using System.Windows.Shapes;
    using System.Collections.Specialized;
    using System.Configuration;
    using System.Data.Common;
    using System.Data;
    using System.Text.RegularExpressions;

    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        private static NameValueCollection _appSettings;
        private int _i;
        private int _max;
        private List<DataSet> _listen;
        private IDictionary<int, Spieler> _spieler = new Dictionary<int,Spieler>();
        private List<Spieler> _spielerListe;
        private IDictionary<int, Spieler> _alleSpieler;
        private Dictionary<string, string> _alleSpiele;

        public MainWindow()
        {
            InitializeComponent();
        }

        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            ReadAppSettings();

            ReadExcell();
        }

        private void ReadExcell()
        {
            string connectionString = _appSettings["ConnectionString"];

            DbProviderFactory factory =
            DbProviderFactories.GetFactory("System.Data.OleDb");

            DbDataAdapter adapter = factory.CreateDataAdapter();

            DbConnection connection = factory.CreateConnection();
            connection.ConnectionString = connectionString;

            bool notstop = true;
            int i = 1;
            List<DataSet> listen = new List<DataSet>();
            _alleSpiele = new Dictionary<string, string>();
            LoadPlayers(connection, factory);
            
            do
            {
                try
                {
                    LoadGame(connection, adapter, factory, i, _appSettings["GegnerName"], "Game_{0}");

                    DbCommand selectCommand = factory.CreateCommand();
                    selectCommand.CommandText = string.Format("SELECT * From [List_{0}$E7:O31]", i);

                    selectCommand.Connection = connection;

                    adapter.SelectCommand = selectCommand;

                    DataSet liste = new DataSet();

                    adapter.Fill(liste);
                    notstop = liste.Tables.Count > 0 && liste.Tables[0].Rows.Count > 0;
                    listen.Add(liste);
                    i++;
                }
                catch (Exception)
                {
                    notstop = false;
                }
            } while (notstop);
            if (listen.Count > 0)
            {
                this.DataContext = listen[0].Tables[0];
            }
            _i = 0;
            _max = listen.Count;
            _listen = listen;
        }

        
        
        private void LoadGame(DbConnection connection,DbDataAdapter adapter, DbProviderFactory factory, int i, string liste, string spiel)
        {
            
            DbCommand selectCommand = factory.CreateCommand();
            selectCommand.CommandText = string.Format("SELECT * From ["+liste+"]", i);

            selectCommand.Connection = connection;

            adapter.SelectCommand = selectCommand;

            DataSet set = new DataSet();

            adapter.Fill(set);
            if(set.Tables.Count == 1 && set.Tables[0].Rows.Count > 0 && set.Tables[0].Columns.Count > 0)
            {
                _alleSpiele.Add(string.Format(spiel,i),Convert.ToString(set.Tables[0].Rows[0][0]).Trim());
            }
        }

        private void LoadPlayers(DbConnection connection, DbProviderFactory factory)
        {
            _alleSpieler = new Dictionary<int,Spieler>();

            DbDataAdapter adapter = factory.CreateDataAdapter();

            DbCommand selectCommand = factory.CreateCommand();
            selectCommand.CommandText = "SELECT * From [Daten$A1:E100]";

            selectCommand.Connection = connection;

            adapter.SelectCommand = selectCommand;

            DataSet spielerDataSet = new DataSet();

            adapter.Fill(spielerDataSet);
            try
            {
                for (int i = 0; i < spielerDataSet.Tables[0].Rows.Count; i++)
                {
                    object[] data = spielerDataSet.Tables[0].Rows[i].ItemArray;

                    if (data[0].GetType() != typeof(DBNull))
                    {
                        int licNum = Convert.ToInt32(data[0]);
                        Spieler spieler = new Spieler(licNum, int.Parse(_appSettings["MaxStreich"]));

                        string name = Convert.ToString(data[1]);
                        string vorname = Convert.ToString(data[2]);

                        
                            if (data[3].GetType() != typeof(DBNull))
                            {
                                DateTime geb = Convert.ToDateTime(data[3]);
                                spieler.GeburtsDatum = geb;
                        
                            }
                        spieler.Name = name;
                        spieler.Vorname = vorname;

                        _alleSpieler.Add(licNum, spieler);
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
            }
        }

        // Get the AppSettings section.        
        // This function uses the AppSettings property
        // to read the appSettings configuration 
        // section.
        public static void ReadAppSettings()
        {
            try
            {
                // Get the AppSettings section.
                NameValueCollection appSettings =
                   ConfigurationManager.AppSettings;

                // Get the AppSettings section elements.
                Console.WriteLine();
                Console.WriteLine("Using AppSettings property.");
                Console.WriteLine("Application settings:");

                if (appSettings.Count == 0)
                {
                    Console.WriteLine("[ReadAppSettings: {0}]",
                    "AppSettings is empty Use GetSection command first.");
                }
                for (int i = 0; i < appSettings.Count; i++)
                {
                    Console.WriteLine("#{0} Key: {1} Value: {2}",
                      i, appSettings.GetKey(i), appSettings[i]);
                }

                _appSettings = appSettings;
            }
            catch (ConfigurationErrorsException e)
            {
                Console.WriteLine("[ReadAppSettings: {0}]",
                    e.ToString());
            }
        }

        private void DataGrid_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {

        }

        private void button1_Click(object sender, RoutedEventArgs e)
        {
            _i++;
            if (_i >= _max)
            {
                _i = 0;
            }
            this.DataContext = _listen[_i].Tables[0];
        }

        private void button2_Click(object sender, RoutedEventArgs e)
        {
            IDictionary<int, Spieler> spieler = _spieler;

            foreach (KeyValuePair<int, Spieler> pair in spieler)
            {
                pair.Value.ResetStreiche();
            }

            List<Spieler> spielerListe;
            CreateStats(spieler, out spielerListe);

            Durchschnittsliste durchschnitt = new Durchschnittsliste();

           
            durchschnitt.Schnitt.DataContext = spielerListe;
            durchschnitt.Schnitt.FontSize = double.Parse(_appSettings["DurchschnittFontS"]);
            //durchschnitt.ShowDialog();

            UIElement vis = durchschnitt.Container as UIElement;


            List<UIElement> elems = new List<UIElement>();
            elems.Add(vis);

            TitelSeiteDurchschnitt durchschnittTitel = new TitelSeiteDurchschnitt();
            GeneralVM vm = new GeneralVM();
            vm.Team = _appSettings["Team"];
            durchschnittTitel.gridContainer.DataContext = vm;

            ShowFlowDocument(elems,durchschnittTitel.Container,vm.Team,"Durchschnitt");

        }

        private void CreateStats(IDictionary<int, Spieler> spieler, out List<Spieler> spielerListe)
        {
            foreach (KeyValuePair<int, Spieler> pair in spieler)
            {
                pair.Value.ResetStreiche();
                pair.Value.Resultate.Clear();
                pair.Value.DurchschnittsResultate.Clear();
            }

            Dictionary<string, int?> dict = new Dictionary<string, int?>();

            int gameIndex = 1;
            try
            {
                foreach (DataSet set in _listen)
                {
                    dict.Add(_alleSpiele["Game_" + gameIndex], null);
                    gameIndex++;
                }
            }
            catch
            {
                MessageBox.Show("Ein Spiel hat den gleichen Titel bitte Korrigieren." + _alleSpiele["Game_" + gameIndex]);
                throw;
            }
            gameIndex = 1;
            foreach (DataSet set in _listen)
            {
                DataTable liste = set.Tables[0];

                DataColumnCollection header = liste.Columns;

                int numRies = 0;
                int startIndex = 0;
                int endIndex = 0;

                for (int i = 0; i < header.Count; i++)
                {
                    string itemValue = header[i].ToString();
                    string itemLower = itemValue.ToLowerInvariant();

                    Regex regex = new Regex("ries");

                    if (regex.IsMatch(itemLower))
                    {
                        numRies++;
                        if (startIndex == 0)
                        {
                            startIndex = i;
                        }
                        endIndex = i;
                    }

                }

                for (int i = 0; i < liste.Rows.Count; i++)
                {
                    object[] data = liste.Rows[i].ItemArray;
                    int maxRowLen = data.Length;
                    double licNumD = -1;

                    if (double.TryParse(data[0].ToString(), out licNumD))
                    {
                        int licNum = Convert.ToInt32(licNumD);
                        if (licNum > 0)
                        {
                            if (!spieler.ContainsKey(licNum))
                            {
                                Spieler spielerVm = _alleSpieler[licNum];
                                spielerVm.Resultate = new Dictionary<string, int?>();
                                spielerVm.DurchschnittsResultate = new Dictionary<string, int?>(dict);
                                spieler.Add(licNum, spielerVm);

                            }

                            Spieler schläger = spieler[licNum];
                            try
                            {
                                schläger.Resultate.Add(_alleSpiele["Game_" + gameIndex], 0);
                            }
                            catch
                            {
                                MessageBox.Show(string.Format("Spieler {0} im Spiel {1} zweimal auf der Liste",schläger.NameLang,_alleSpiele["Game_" + gameIndex]));
                                throw;
                            }
                            for (int j = startIndex; j <= endIndex; j++)
                            {
                                double streichD = -1;
                                if (double.TryParse(data[j].ToString(), out streichD))
                                {
                                    int streich = Convert.ToInt32(streichD);

                                    if (schläger.Resultate[_alleSpiele["Game_" + gameIndex]] == null)
                                    {
                                        schläger.Resultate[_alleSpiele["Game_" + gameIndex]] = streich;
                                    }
                                    else
                                    {
                                        schläger.Resultate[_alleSpiele["Game_" + gameIndex]] += streich;
                                    }

                                    if (schläger.Streiche.ContainsKey(streich))
                                    {
                                        schläger.Streiche[streich]++;
                                    }
                                }
                            }

                            int streiche = endIndex;
                            int? result = schläger.Resultate[_alleSpiele["Game_" + gameIndex]];
                            if ( streiche != 4 &&  result != null)
                            { 
                              //Correct Result to 4 game result schnitt
                              double res = (double)result;
                              double newResult = (res / streiche) * 4.0;
                              schläger.Resultate[_alleSpiele["Game_" + gameIndex]] = (int?)Math.Round(newResult);
                            }

                        }
                    }
                }
                gameIndex++;
            }

          

          spielerListe = new List<Spieler>(spieler.Values);

          _spielerListe = spielerListe;


          foreach (Spieler schläger in spielerListe)
          {
              double anzahlStreiche = schläger.AnzahlStreiche;
              if (Spieler.MaxStreiche < anzahlStreiche)
              {
                  Spieler.MaxStreiche = anzahlStreiche;
              }
          }
          Spieler.Streichgrenze = double.Parse(_tbStreichGrenze.Text);

          spielerListe.Sort();
          spielerListe.Reverse();

          for (int i = 1, j = 0; i <= spielerListe.Count; i++, j++)
          {
            spielerListe[j].Position = i;
          }
        }

        private static void ShowFlowDocument(List<UIElement> visus, UIElement titelSeite, string team , string titel)
        {
          FixedDocument fixedDoc = new FixedDocument();
          fixedDoc.Name = string.Format("{0}{1}{2}",titel,team, DateTime.Now.ToString("dd_MM_yyyy")); ;
          PageContent pageContent = new PageContent();
          FixedPage fixedPage = null;
           if(titelSeite != null)
           {
                fixedPage = CreatePage(new List<UIElement>(new UIElement[] {titelSeite}), titelSeite);
               //Create first page of document
                ((System.Windows.Markup.IAddChild)pageContent).AddChild(fixedPage);
                fixedDoc.Pages.Add(pageContent);
           }
          

          foreach (UIElement vis in visus)
          {
            pageContent = new PageContent();
            fixedPage = CreatePage(visus, vis);

            ((System.Windows.Markup.IAddChild)pageContent).AddChild(fixedPage);
            fixedDoc.Pages.Add(pageContent);
            //Create any other required pages here
          }
          //View the document
          DocumentViewerContainer container = new DocumentViewerContainer();
          container.Title = fixedDoc.Name;
          container.DocumentViewer.Document = fixedDoc;
          
          container.ShowDialog();
        }

        private static FixedPage CreatePage(List<UIElement> visus, UIElement vis)
        {
            FixedPage fixedPage = new FixedPage();

            FixedPage.SetLeft(vis, 0);
            FixedPage.SetTop(vis, 0);

            double pageWidth = 96 * 8.5;
            double pageHeight = 96 * 11;


            fixedPage.Width = pageWidth;
            fixedPage.Height = pageHeight;

            fixedPage.Children.Add(vis);

            Size sz = new Size(8.5 * 96, 11 * 96);
            fixedPage.Measure(sz);
            fixedPage.Arrange(new Rect(new Point(), sz));
            fixedPage.UpdateLayout();

            if (visus.Count == 1)
            {
                //Center the visual 
              
                FixedPage.SetLeft(vis, (pageWidth - vis.DesiredSize.Width) / 2);
                FixedPage.SetTop(vis, (pageHeight - vis.DesiredSize.Height) / 2);

                sz = new Size(8.5 * 96, 11 * 96);
                fixedPage.Measure(sz);
                fixedPage.Arrange(new Rect(new Point(), sz));
                fixedPage.UpdateLayout();
            }
            return fixedPage;
        }

        private void button3_Click(object sender, RoutedEventArgs e)
        {
          IDictionary<int, Spieler> spieler = _spieler;

          foreach (KeyValuePair<int, Spieler> pair in spieler)
          {
            pair.Value.ResetStreiche();
          }

          List<Spieler> spielerListe;
          CreateStats(spieler, out spielerListe);

          int modIdx = Convert.ToInt32(_tbSpielerProSeite.Text);

          spielerListe.Sort(new StandardabweichungsComparer());

          List<Spieler>[] spielerlistenabschnitte = Partition<Spieler>(spielerListe, modIdx);

          List<UIElement> elems = new List<UIElement>();

          foreach (List<Spieler> list in spielerlistenabschnitte)
          {
            Streichuebersicht streiche = new Streichuebersicht();
            streiche.ItemsControl.DataContext = list;
            elems.Add(streiche.Container);
          }
         
          GeneralVM generalVm = new GeneralVM();
          generalVm.Team = _appSettings["Team"];

          TitelSeiteStreichuebersicht titelSeite = new TitelSeiteStreichuebersicht();
          titelSeite.gridContainer.DataContext = generalVm;


          ShowFlowDocument(elems, titelSeite.Container, generalVm.Team, "Streichuebersicht");
        }

        public static List<T>[] Partition<T>(List<T> list, int size)
        {
          if (list == null)
            throw new ArgumentNullException("list");

          
          int count = (int)Math.Ceiling(list.Count / (double)size);
          List<T>[] partitions = new List<T>[count];

          int k = 0;
          for (int i = 0; i < partitions.Length; i++)
          {
            partitions[i] = new List<T>(size);
            for (int j = k; j < k + size; j++)
            {
              if (j >= list.Count)
                break;
              partitions[i].Add(list[j]);
            }
            k += size;
          }

          return partitions;
        }

        private void button4_Click(object sender, RoutedEventArgs e)
        {
            IDictionary<int, Spieler> spieler = _spieler;

            foreach (KeyValuePair<int, Spieler> pair in spieler)
            {
                pair.Value.ResetStreiche();
            }

            List<Spieler> spielerListe;
            CreateStats(spieler, out spielerListe);

            Dictionary<string, int?> dict = new Dictionary<string, int?>();

            int gameIndex = 1;
            foreach (DataSet set in _listen)
            {
                dict.Add(_alleSpiele["Game_" + gameIndex], null);
                gameIndex++;
            }

            spielerListe.Sort();
            spielerListe.Reverse();

            for (int i = 1, j = 0; i <= spielerListe.Count; i++, j++)
            {
                spielerListe[j].Position = i;
                int durchschnittsResultat = Convert.ToInt32(spielerListe[j].Durchschnitt * 4.0);
                foreach (string key in dict.Keys)
                {
                    spielerListe[j].DurchschnittsResultate[key] = durchschnittsResultat;
                }
            }

            _spielerListe = spielerListe;

            int modIdx = Convert.ToInt32(_tbSpielerProResSeite.Text);

            List<Spieler>[] spielerlistenabschnitte = Partition<Spieler>(spielerListe, modIdx);

            List<UIElement> elems = new List<UIElement>();

            foreach (List<Spieler> list in spielerlistenabschnitte)
            {
                Resultateuebersicht resultate = new Resultateuebersicht();
                resultate.ItemsControl.DataContext = list;
                elems.Add(resultate.Container);
            }

            GeneralVM generalVm = new GeneralVM();
            generalVm.Team = _appSettings["Team"];

            TitelSeiteResultatuebersicht titelSeite = new TitelSeiteResultatuebersicht();
            titelSeite.gridContainer.DataContext = generalVm;


            ShowFlowDocument(elems, titelSeite.Container,generalVm.Team, "Resultateuebersicht");
            
        }

        
    }

}

/*
 * History of MKS Source Code Control System
 *
 * $Log: $
 * 
 */